home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1999 March / EnigmA AMIGA RUN 35 (1999)(G.R. Edizioni)(IT)[!][issue 1999-03].iso / earcd / devel / libx11 / include / x11 / wc / wccreate.h < prev    next >
C/C++ Source or Header  |  1999-01-01  |  48KB  |  1,118 lines
  1. #ifndef _WcCreate_h
  2. #define _WcCreate_h
  3. #include <X11/Wc/COPY>
  4. #include <stdio.h>
  5.  
  6. /*
  7. * SCCS_data: @(#) WcCreate.h 1.9 92/06/10 06:11:13
  8. *
  9. * Widget Creation Library - WcCreate.h
  10. *
  11. * Everything declared in this file is the public definition of Wcl version 2.
  12. * No interfaces will be deleted or changed until Wcl 3, but things might be
  13. * added.
  14. *
  15. *******************************************************************************
  16. */
  17.  
  18. /****************************************************************************** 
  19. *  Applications should append the WCL_XRM_OPTIONS macro to their
  20. *  XrmOptionDescRec declaration so a user can specify Wcl specific options
  21. *  easily from the command line.
  22. *
  23. *  Applications should also always call WcAppClass( argc, argv ) to
  24. *  get the application class name from the command line, which can
  25. *  then be passed to XtInitialize().  WcAppClass() looks for
  26. *  -name <appName> in the argv, or else it capitalizes the first letter
  27. *  of argv[0] (or first two if the first is already capitalized).
  28. *
  29. *  Therefore, a typical Wcl based application should look something like this:
  30. ******************************************************************************
  31.     #include <X11/Wc/WcCreate.h>
  32.  
  33.     static XrmOptionDescRec options[] = {
  34.     { ... other application specific options ... },
  35.     WCL_XRM_OPTIONS
  36.     };
  37.  
  38.     main( argc, argv )
  39.     int    argc;
  40.     char** argv;
  41.     {
  42.     Widget appShell = XtInitialize(
  43.         argv[0],
  44.         WcAppClass( argc, argv ),
  45.         options, XtNumber(options),
  46.         &argc, argv );
  47.  
  48.     ... register widgets, callbacks, and actions ...
  49.  
  50.     if ( WcWidgetCreation ( appShell ) )
  51.         exit(1);
  52.  
  53.     XtRealize( appShell );
  54.     XtMainLoop();
  55.     }
  56. ******************************************************************************
  57. */
  58.  
  59. #define WCL_XRM_OPTIONS \
  60.     { "-ResFile",    "*wclResFiles",        XrmoptionSepArg, NULL }, \
  61.     { "-rf",        "*wclResFiles",        XrmoptionSepArg, NULL }, \
  62.     { "-Trace",        "*wcTrace",        XrmoptionNoArg,  "on" }, \
  63.     { "-tr",        "*wcTrace",        XrmoptionNoArg,  "on" }, \
  64.     { "-trtd",        "*wclTraceTemplateDef",    XrmoptionNoArg,     "on" }, \
  65.     { "-trtx",        "*wcTraceTemplate",    XrmoptionNoArg,     "on" }, \
  66.     { "-Warnings",    "*wclVerboseWarnings",    XrmoptionNoArg,  "on" }
  67.  
  68. /******************************************************************************
  69. ** Resources Fetched By Wcl
  70. ******************************************************************************
  71. *  Resources beginning with "wcl" (class names beginning with "Wcl") apply
  72. *  to an application instance.  Such resources are fetched by
  73. *  WcInitialize() as resources of the initial top level shell.  These
  74. *  resources are never fetched again during the life of an application.
  75. *
  76. *  WcWidgetCreation() calls WcInitialize() before creating any widgets.
  77. *
  78. *  Application Wide Resources:
  79. ******************************************************************************
  80. * WclResFiles            List of files to be loaded into resource db.
  81. * WclErrorDatabaseFile        File with overrides for Wcl warning messages.
  82. * WclWidgetResourceFiles    Files with widget resources not reported by
  83. *                XtGetConstraintResourceList() nor by
  84. *                XtGetResourceList(). ** not yet implemented **
  85. * WclTemplateFiles        List of files with templates.
  86. * WclTraceTemplateDef        Trace definition of templates to stderr.
  87. * WclVerboseWarnings        Some warnings are supressed normally, but this
  88. *                resource causes Wcl to act like ANSI C and
  89. *                give somewhat informative but usually annoying
  90. *                messages.
  91. * WclDynamicLibs        List of full pathnames of libraries which
  92. *                can be named using "-lName" shorthand in
  93. *                WcDynamicAction(), WcDynamicCallback(), and in
  94. *                the new (Wcl 2.02) callback and method syntax.
  95. */
  96. #define WcNwclResFiles            "wclResFiles"
  97. #define WcNwclErrorDatabaseFile        "wclErrorDatabaseFile"
  98. #define WcNwclWidgetResourceFiles    "wclWidgetResourceFiles"
  99. #define WcNwclTemplateFiles        "wclTemplateFiles"
  100. #define WcNwclTraceTemplateDef        "wclTraceTemplateDef"
  101. #define WcNwclVerboseWarnings        "wclVerboseWarnings"
  102. #define WcNwclDynamicLibs        "wclDynamicLibs"
  103.  
  104. #define WcCWclResFiles            "WclResFiles"
  105. #define WcCWclErrorDatabaseFile        "WclErrorDatabaseFile"
  106. #define WcCWclWidgetResourceFiles    "WclWidgetResourceFiles"
  107. #define WcCWclTemplateFiles        "WclTemplateFiles"
  108. #define WcCWclTraceTemplateDef        "WclTraceTemplateDef"
  109. #define WcCWclVerboseWarnings        "WclVerboseWarnings"
  110. #define WcCWclDynamicLibs        "WclDynamicLibs"
  111.  
  112. /* Widget Creation Time Resources - Before Instance Creation:
  113. ******************************************************************************
  114. * These resources are fetched before each widget instance is created by
  115. * the Wcl widget creation recursion.  Since they are fetched before the
  116. * class of the widget is truly known, they apply to an instance (or
  117. * template) name, not to a widget class name.
  118. *
  119. * NOTE: The Wcl 1.x instance creation time resource "wcResFile" is no
  120. * longer supported.  Its use was dangerous.  Change all occurances of
  121. * "wcResFile" to use the new "wclResFiles" 
  122. */
  123.  
  124. #define WcNwcPreCreateDumpResources    "wcPreCreateDumpResources"
  125. #define WcNwcTemplate            "wcTemplate"
  126. #define WcNwcTraceTemplate        "wcTraceTemplate"
  127. #define WcNwcPostTemplateDumpResources    "wcPostTemplateDumpResources"
  128. #define WcNwcCreate            "wcCreate"
  129. #define WcNwcClassName            "wcClassName"        /* OBSOLETE */
  130. #define WcNwcClass            "wcClass"        /* OBSOLETE */
  131. #define WcNwcConstructor        "wcConstructor"        /* OBSOLETE */
  132.  
  133. #define WcCWcDumpResources        "WcDumpResources"
  134. #define WcCWcTemplate            "WcTemplate"
  135. #define WcCWcTraceTemplate        "WcTraceTemplate"
  136. #define WcCWcCreate            "WcCreate"
  137. #define WcCWcClassName            "WcClassName"        /* OBSOLETE */
  138. #define WcCWcClass            "WcClass"        /* OBSOLETE */
  139. #define WcCWcConstructor        "WcConstructor"        /* OBSOLETE */
  140.  
  141. /* Widget Creation Time Resources - After Instance Creation:
  142. ******************************************************************************
  143. * These resources are fetched after each widget instance is created by
  144. * the Wcl widget creation recursion.  The class of the widget is then
  145. * known, so these resources may be specified on a widget class basis.
  146. *
  147. * If a constructor was used to create the instance, and this constructor
  148. * creates additional parents of the instance (e.g., XmCreateMessageDialog
  149. * creates a dialog shell before creating the XmMessageBox), then these
  150. * resources MUST be preceeded by either an "*" or the name of the
  151. * automatically created parent (e.g., childName_popup in the case of
  152. * XmCreateMessageDialog).
  153. */
  154.  
  155. #define WcNwcTrace            "wcTrace"
  156. #define WcNwcPostCreateDumpResources    "wcPostCreateDumpResources"
  157. #define WcNwcCallback            "wcCallback"
  158. #define WcNwcPopups            "wcPopups"
  159. #define WcNwcChildren            "wcChildren"
  160. #define WcNwcManaged            "wcManaged"
  161. #define WcNwcAfterPopups        "wcAfterPopups"
  162. #define WcNwcAfterChildren        "wcAfterChildren"
  163. #define WcNwcAfterManageChildren    "wcAfterManageChildren"
  164.  
  165. #define WcCWcTrace            "WcTrace"
  166. #define WcCWcCallback            "WcCallback"
  167. #define WcCWcPopups            "WcPopups"
  168. #define WcCWcChildren            "WcChildren"
  169. #define WcCWcManaged            "WcManaged"
  170. #define WcCWcAfterPopups        "WcAfterPopups"
  171. #define WcCWcAfterChildren        "WcAfterChildren"
  172. #define WcCWcAfterManageChildren    "WcAfterManageChildren"
  173.  
  174. /* Resource Types for Wcl Resources
  175. */
  176. #define WcRDynamicLibs            "DynamicLibs"
  177. #define WcRQuarkRec            "QuarkRec"
  178. #define WcRQuark            "Quark"
  179.  
  180. /******************************************************************************
  181. ** Macros for ANSI and K&R Function Decls
  182. ******************************************************************************/
  183.  
  184. #ifndef NeedFunctionPrototypes
  185. #if defined(FUNCPROTO) || defined(__STDC__) || defined(__cplusplus) || defined(c_plusplus)
  186. #define NeedFunctionPrototypes 1
  187. #else
  188. #define NeedFunctionPrototypes 0
  189. #endif /* __STDC__ */
  190. #endif /* NeedFunctionPrototypes */
  191.  
  192. /* Macro for ANSI or K&R external declarations.  Declare them like this:
  193. **
  194. **      int foo _(( int, MapAg ));
  195. **
  196. ***************** DO NOT forget whitespace before the '_' !! *****************
  197. */
  198. #if NeedFunctionPrototypes
  199. #define _(a) a          /* ANSI results in: int foo ( int, MapAg ); */
  200. #else
  201. #define _(a) ()         /* K&R  results in: int foo ();                       */
  202. #endif
  203.  
  204. /******************************************************************************
  205. ** Wcl Public Functions
  206. ******************************************************************************/
  207.  
  208. /* -- Wcl requires these XtR4 declarations: ********************************/
  209. #ifndef XtSpecificationRelease
  210. #ifdef __STDC__
  211. typedef void*    XtPointer;
  212. #else
  213. typedef char*    XtPointer;
  214. #endif
  215. #ifndef XtName
  216. extern char* XtName _(( Widget ));    /* from ./XtName.c if not in libXt */
  217. #endif
  218. #endif    /* !XtSpecificationRelease *****************************************/
  219.  
  220. /* -- Function Pointer Typedefs
  221. */
  222. typedef Widget (*WcWidgetConstructor) _((Widget,char*,ArgList,Cardinal));
  223.  
  224. /*====================================================================
  225.  * Widget class, constructor, and callback proc registration routines:
  226.  * Registrations are kept separate for each application context.
  227.  * The names are used in resource files as RHS (values).
  228.  * Multiple names can be registered for any widget class, callback, etc.
  229.  */
  230.  
  231. /* -- Register name of widget class pointer, so name can be used as value of
  232.  *    wcCreate resources.  You might want to register mySpecialWidgetClass as
  233.  *    both "mySpecialWidgetClass" and "MySpecial", the first being the C name
  234.  *    for the widget class pointer, the second being the widget class name
  235.  *    as stored in the widget's class record.
  236.  */
  237. extern void WcRegisterClassPtr _((
  238.         XtAppContext,
  239.         char*,        /* name of class pointer, used for wcCreate */ 
  240.         WidgetClass
  241. ));
  242.  
  243. extern void WcRegisterClassName _(( /* OBSOLETE - use WcRegisterClassPtr */
  244.         XtAppContext,
  245.         char*,        /* name of class pointer, used for wcCreate */
  246.         WidgetClass
  247. ));
  248.  
  249. /* -- Register name of widget constructor function, so name can be used as
  250.  *    value of wcCreate resources.
  251.  */
  252. extern void WcRegisterConstructor _((
  253.         XtAppContext,
  254.         char*,        /* name of constructor, used for wcCreate */
  255.         WcWidgetConstructor
  256. ));
  257.  
  258. /* -- Register the name of XtCallbackProcs so they may be named as callback
  259.  *    resources for widgets.  The registration-time client data is NOT very
  260.  *    useful: it only gets passed to the callback if there is nothing inside
  261.  *    of (the optional) parenthesis following the callback name in the resource
  262.  *    value specification.  Normally, you should use a mapping agent (see
  263.  *    MapAg.h) or the X Context Manager (see XFindContext, XSaveContext) to
  264.  *    obtain arbitrary data related to widgets.  Or, use object-oriented
  265.  *    design and use the Wcl Method concept...
  266.  */
  267. extern void WcRegisterCallback _((
  268.         XtAppContext,
  269.         char*,        /* callback proc name for resource value */
  270.         XtCallbackProc,    
  271.         XtPointer    /* not very useful... I always use NULL */
  272. ));
  273.  
  274. /* -- Provides symmetry with WcRegisterCallback().  It is more efficient
  275.  *    to declare your own XtActionsRec[] and call XtAppAddActions().
  276.  */
  277. extern void WcRegisterAction _((
  278.         XtAppContext,
  279.         char*,        /* action proc name for translations */
  280.         XtActionProc
  281. ));
  282.  
  283. /* -- If a callback proc cannot be found given a name specified in a resource
  284.  *    value, then the "UndefinedCallback" is invoked.  The client data is the
  285.  *    name and arguments (more-or-less) as specified in the resource value.
  286.  *    You can provide your own callback which will then be invoked instead of
  287.  *    the default "UndefinedCallback".  The return value is the address of the
  288.  *    previous "UndefinedCallback".
  289.  */
  290. extern XtCallbackProc WcSetUndefinedCallback     _(( XtCallbackProc ));
  291.  
  292. /*=============================================================================
  293.  * Method Support:  Callback resource value specifications can now name methods
  294.  * instead of only simple callbacks.  A method specification in a callback
  295.  * resource value looks like this:
  296.  *
  297.  *    <class_name>::<method_name>(<opt_args>)
  298.  *
  299.  * The callback method gets a pointer to a special struct as the client data.
  300.  * The struct has three elements: a pointer to the "object" of the appropriate
  301.  * class, an arbitrary pointer which is provided at registration time, and the
  302.  * characters inside of parenthesis in the resource value (leading and trailing
  303.  * whitespace stripped, at least a pointer to a null character, never a null
  304.  * pointer).
  305.  *
  306.  * Note that this makes the registration-time client data much more useful than
  307.  * the original Wcl callback registration mechanisms: the original callback
  308.  * mechanism only provides the registration-time client data if there is nothing
  309.  * between parens in the resource file.  The new method mechanism ALWAYS
  310.  * provides the registration-time client data.
  311.  *
  312.  * Class names CANNOT begin with the two characters "-l" in order to avoid
  313.  * ambiguities with the Dynamic Linking Support (see below).
  314.  *
  315.  * Wcl uses late binding to invoke methods.  At invocation time, Wcl resolves
  316.  * the method address, and it attempts to find an object of the appropriate
  317.  * class.  The run-time overhead is kept low: about 20 lines of C are executed
  318.  * for typical method invocations.  
  319.  *
  320.  * Wcl provides a default mechanism for finding object which is baed on the
  321.  * following observations:  Often, an object in the application is mapped 1:1
  322.  * with some shell or manager widget, and the children of that shell or manager
  323.  * widget provide ways to display or set attributes on the object, and invoke
  324.  * methods on the object.  Imagine a dialog box for a text editor which is used
  325.  * to display and manipulate paragraph properties.  The application changes the
  326.  * "Paragraph" object related to the dialog as the insertion point moves from
  327.  * paragraph to paragraph.  Pressing a button labeled "Right Justify" may
  328.  * invoke the RightJustify method of the current paragraph.  The resource
  329.  * specification would look like this:
  330.  *
  331.  *    *parProp*rightJustify.callback:    Paragraph::RightJustify()
  332.  *
  333.  * The default object resolution mechanism uses WcAttachThisToWidget() and
  334.  * WcDetachThisFromWidget() to allow the application to set and change the
  335.  * objects related to widgets in the interface.
  336.  *
  337.  * An application can get the address of the default object resolution function
  338.  * and provide its own which replaces or envelopes the default resolution logic.
  339.  * Use WcSetFindObjectFunc() to get the old resolution function and provide a
  340.  * replacement which will be called to get the object pointer.
  341.  *
  342.  * NOTE: it is very possible that no object of the appropriate type is found
  343.  * by an object resolution procedure.  Wcl can optionally issue a warning
  344.  * message if this occurs, BUT THE METHOD IS INVOKED ANYWAY!  This means that
  345.  * methods MUST detect NULL object pointers and handle them reasonably.
  346.  *
  347.  * Some methods do not need object pointers: object constructors are a common
  348.  * and useful example.
  349.  */
  350. extern void WcRegisterMethod _((
  351.         XtAppContext,
  352.         char*,        /* object class name - CANNOT begin with "-l" */
  353.         char*,        /* method name */
  354.         XtCallbackProc,    /* method is still an XtCallbackProc */
  355.         XtPointer    /* registered client data - can be useful */
  356. ));
  357.  
  358. /* -- A pointer to this struct is passed as client data to methods.  This struct
  359.  *    may become longer in future releases.  The object pointer my be NULL!  The
  360.  *    method must detect NULL object pointers.
  361.  */
  362. typedef struct _WcMethodDataRec {
  363.  
  364.     XtPointer    object;        /* pointer to application obj or NULL */
  365.     XtPointer    closure;    /* client data registered with method name */
  366.     char*    args;        /* from between parens in resource value */
  367.  
  368. } WcMethodDataRec, *WcMethodData;
  369.  
  370. /* -- Set the function used to find an object of a particular class from
  371.  *    a widget invoking a callback.  The default function provided by Wcl
  372.  *    searches up the widget tree, looking for objects attached to widgets.
  373.  *    Some applications may want to use different approaches to finding an
  374.  *    object, such as using a server, loading objects from files, collections,
  375.  *    MappingAgents, etc...
  376.  *    The previous function is returned.
  377.  */
  378. typedef XtPointer (*WcFindObjectFunc) _((
  379.         Widget,        /* widget invoking the callback */
  380.         XrmQuark    /* quarkified case sensitive class name */
  381. ));
  382.  
  383. extern WcFindObjectFunc WcSetFindObjectFunc _((
  384.         WcFindObjectFunc    /* application provided function ptr */
  385. ));
  386.  
  387. /* -- Set the object pointer related to a widget.  These may become useless
  388.  *    if you use WcSetFindObjectFunc...
  389.  */
  390. extern void WcAttachThisToWidget _((
  391.         XtPointer,    /* "this" pointer, pointer to application obj */
  392.         char*,        /* object class name - CANNOT begin with "-l" */
  393.         Widget        /* object will be `attached' to the widget */
  394. ));
  395.  
  396. /* -- Un-set the object pointer related to a widget.
  397.  *    The "this" pointer is unused: actually, any object of the indicated
  398.  *    class is detached from the widget.
  399.  */
  400. extern void WcDetachThisFromWidget _((
  401.         XtPointer,    /* "this" pointer, pointer to application obj */
  402.         char*,        /* object class name - CANNOT begin with "-l" */
  403.         Widget        /* any object of "class" will be detached */
  404. ));
  405.  
  406. /*============================================================================
  407.  * Dynamic Linking Support:  Callback resource value specifications can now
  408.  * name dynamic libraries which can be used to resolve callback procedure
  409.  * addresses.  Both "old-fashioned" Wcl style callbacks and "new-fangled"
  410.  * Wcl style methods can be bound using this mechanism.  The resolution of
  411.  * addresses is done once, before the first invocation of a callback or a
  412.  * method.  Callback resource specification which use dynamic libraries look
  413.  * like this:
  414.  *
  415.  *    -l<library_abbreviation>::<callback_name>(<opt_args>)
  416.  * or    -l<library_abbreviation>::<class_name>::<method_name>(<opt_args>)
  417.  *
  418.  * Note that the initial "-l" of library specifications eliminated any
  419.  * ambiguity between library names and class names used for methods.
  420.  *
  421.  * The library abbreviation is the same as that used by the "ld" command:
  422.  * the library /usr/X11R5/lib/libXop.so.2.2 can be named by "-lXop".
  423.  *
  424.  * Libraries must be registered with Wcl before they are needed (before the
  425.  * first callback invokation which names the library).  Libraries may be
  426.  * registered using the function below, and by using the application-wide
  427.  * resource "wclDynamicLibs" which is fetched and evaluated during Wcl
  428.  * initialization.  Multiple libraries can be registered at once: each full
  429.  * pathname is separated by whitespace and/or a comma.
  430.  */
  431. extern void WcRegisterDynamicLibs _((
  432.         XtAppContext,
  433.         char*        /* full path names of dynamic libraries */
  434. ));
  435.  
  436. /*============================================================================
  437.  * Initialization and initial widget tree creation routines:  WcInitialize()
  438.  * must be called before any widgets are created by Wcl.  Many applications
  439.  * simply use the function WcWidgetCreation() to initialize Wcl and to create
  440.  * the initial non-empty widget tree.  WcWidgetCreation complains and returns
  441.  * 1 if no popups or children of the application shell could be created.  If
  442.  * your application does not have an initial non-empty widget tree, then you
  443.  * should invoke WcInitialize() and then dynamically create the widget trees
  444.  * as needed.
  445.  */
  446. extern int  WcWidgetCreation _((    /* 1 if failed, 0 if OK */
  447.         Widget             /* appShell from XtInitialize */
  448. ));
  449.  
  450. extern void WcInitialize _((        /* called by WcWidgetCreation */
  451.         Widget            /* appShell from XtInitialize */
  452. ));
  453.  
  454. /*============================================================================
  455.  * Create Widgets Dynamically:  Each of these functions can create an entire
  456.  * widget tree starting with the named child.  Functions which create a single
  457.  * direct descendent child return the widget id of the new child.  Functions
  458.  * which may create multiple direct descendents return void.
  459.  *
  460.  * Child names are always single elements (like "newChild", not like
  461.  * "somechild*aDistantDescendant").  Names of children are passed as a single
  462.  * null terminated string, with whitespace and/or a comma separating each
  463.  * child name.
  464.  *
  465.  * The type of the child as well as other Wcl creation-time resources of the
  466.  * child are fetched and evaluated.  Therefore, wcPopups and wcChildren
  467.  * resources of the child widget can cause arbitrarily complex widget trees to
  468.  * be created.  However, NONE of the parent's resources are re-evaluated.
  469.  * Specifically, this means the Wcl creation-time callbacks of the parent are
  470.  * NOT invoked.
  471.  * WcCreateChild():        Child is NOT managed.
  472.  * WcCreateChildFromTemplate():    Child is NOT managed.
  473.  * WcCreateNamedPopups():    Children are NOT popped up.
  474.  * WcCreatePopup():        Child is NOT popped up.
  475.  * WcCreatePopupFromTemplate():    Child is NOT popped up.
  476.  * WcCreateRoot():        Shell is realized.
  477.  */ 
  478.  
  479. /* -- Each child of the parent may be managed as controlled by child's
  480.  *    wcManaged resource.
  481.  */
  482. extern void WcCreateNamedChildren _((
  483.         Widget,        /* parent widget */
  484.         char*        /* names of children to be created */
  485. ));
  486.  
  487. /* -- Child is NOT managed.
  488. */
  489. extern Widget WcCreateChild _((
  490.         Widget,        /* parent widget */
  491.         char*        /* name of child to be created */
  492. ));
  493.  
  494. /* -- Child is NOT managed.  Template applied before creation.
  495. */
  496. extern Widget WcCreateChildFromTemplate _((
  497.         Widget,        /* parent widget */
  498.         char*,        /* name of child to be created */
  499.         char*        /* template name */
  500. ));
  501.  
  502. /* -- Children are NOT popped up.
  503. */
  504. extern void WcCreateNamedPopups _((
  505.         Widget,        /* parent widget */
  506.         char*        /* names of popup children to be created */
  507. ));
  508.  
  509. /* -- Child is NOT popped up.
  510. */
  511. extern Widget WcCreatePopup _((
  512.         Widget,        /* parent widget */
  513.         char*        /* name of popup child to be created */
  514. ));
  515.  
  516. /* -- Child is NOT popped up.  Template applied before creation.
  517. */
  518. extern Widget WcCreatePopupFromTemplate _((
  519.         Widget,        /* parent widget */
  520.         char*,        /* name of popup child to be created */
  521.         char*        /* template name */
  522. ));
  523.  
  524. /* -- Creates an application shell.  Therefore, this MUST be created
  525.  *    on a new display connection to avoid problems.  The shell is realized,
  526.  *    which generally causes it to appear.
  527.  */
  528. extern Widget WcCreateRoot _((
  529.         Display*,    /* A different connection than other roots! */
  530.         char*        /* name of shell to be created */
  531. ));
  532.  
  533. /*===========================================================================
  534.  * Resource Database Dumping Capabilities - require X11R5
  535.  * These allow you to dump portions of the resource database into stdio files.
  536.  */
  537.  
  538. /* -- Dump resources which apply to a widget before it is created, note that
  539.  *    we do not know the class name yet, so no resources which are terminally
  540.  *    named by a widget class name (like *XpTable.defaultOptions) will be
  541.  *    found.
  542.  */
  543. extern void WcPreCreateDumpResources _((
  544.         Widget,        /* parent widget */
  545.         char*,        /* name of (usually) not-yet-created child */
  546.         FILE*        /* stderr, stdout, or opened with fopen() */
  547. ));
  548.  
  549. /* -- Dump all resources which apply to a widget after the widget has been
  550.  *    created.  The class is now known, the final full path of the child is
  551.  *    known, and templates have been applied.  The resources shown will be
  552.  *    the same which the widget sees and responds to in its core.Initialize()
  553.  *    method.
  554.  */
  555. extern void WcPostCreateDumpResources _((
  556.         Widget,        /* the widget */
  557.         FILE*        /* stderr, stdout, or opened with fopen() */
  558. ));
  559.  
  560. /*===========================================================================
  561.  * Widget name routines
  562.  */
  563.  
  564. /* -- Find named widget starting from reference widget.
  565.  *    WcFullNameToWidget examines the first few characters of the `name'
  566.  *    argument in order to determine where the search will begin.
  567.  *
  568.  *    The `name' can begin with one or more of the relative prefix operators
  569.  *    which are evaluated from left-to-right:
  570.  *
  571.  *    this    must be first, means "the reference widget";
  572.  *    ^    means "parent";
  573.  *    ~    means "closest shell ancestor";
  574.  *    .    ignored, can be used stylistically.
  575.  *
  576.  *    Following the relative pre-fix operators can be a normal widget path
  577.  *    name which is simply passed to XtNameToWidget().  Therefore, the rest
  578.  *    of the path can include "*", widget instance names and widget class
  579.  *    names, but of course the last component must be an instance name.
  580.  *
  581.  *    If the name begins with `*' as the first character, then the root
  582.  *    widget starting from the reference widget is used as the reference
  583.  *    widget.  This is very different from XtNameToWidget!  Use "this*foo"
  584.  *    if you want to get the same widget which XtNameToWidget(this,"*foo")
  585.  *    would find.
  586.  */
  587. extern Widget WcFullNameToWidget _((
  588.         Widget,        /* reference widget */
  589.         char*        /* relative path name to another widget */
  590. ));
  591.  
  592. /* -- This is a bug-fixed version of XtNameToWidget().  Pre-X11R4 and early
  593.  *    X11R4 versions of XtNameToWidget dump core when a Gadget is encountered.
  594.  *    This version is the late Rr and R5 version which can deal properly with
  595.  *    Gadgets.
  596.  */
  597. extern Widget WcChildNameToWidget _((
  598.         Widget,        /* starting widget */
  599.         char*        /* path to child widget */
  600. ));
  601.  
  602. /* -- Returns the full path name of a widget starting from its root
  603.  *    widget.  The string is XtAlloc'd, so use XtFree() when done.
  604.  */
  605. extern char* WcWidgetToFullName _(( Widget ));
  606.  
  607. /*  -- Print the widget tree starting from this widget
  608. */
  609. extern void WcPrintTree  _(( Widget ));
  610.  
  611. /*============================================================================
  612.  * Parsing and various string utilities.
  613.  */
  614.  
  615. /* -- Obtain application class from the argv passed to main()
  616.  *    The caller must free return values with XtFree().
  617.  */
  618. extern char* WcAppClass _((
  619.         int,        /* argc passed to main() */
  620.         char**        /* argv passed to main() */
  621. ));
  622.  
  623. /* -- Convert an application name into an application class name using
  624.  *    the X convention (capitalizes first letter, or first two if first
  625.  *    is already capitalized)
  626.  */
  627. extern char* WcAppNameToAppClass _((
  628.         char*        /* application name (usually argv[0]) */
  629. ));
  630.  
  631. /* -- Returns the character pointer argument advanced past whitespace,
  632.  *    and '\0' at end of string.
  633.  */
  634. extern char* WcSkipWhitespace        _(( char* ));
  635.  
  636. /* -- Returns the character pointer argument advanced past whitespace and
  637.  *    optional comma.  Commas can be used to indicate null fields.  If a
  638.  *    field is null, the comma is returned.  Returns '\0' at end of string.
  639.  */
  640. extern char* WcSkipWhitespace_Comma    _(( char* ));    /* optional comma   */
  641.  
  642. /* -- WcCleanName is ugly, but effective.  The first argument is the string to
  643.  *    find a name surrounded by whitespace.  The second is a buffer provided
  644.  *    by the caller into which WcCleanName builds a null terminated string.
  645.  *    The return value points at the next character WcCleanName should process
  646.  *    if continuing to get names from the same initial string.
  647.  */
  648. extern char* WcCleanName _((
  649.         char*,        /* string with a bunch of words */
  650.         char*        /* pre-allocd char array to be filled in */
  651. ));
  652.  
  653. /*  -- get quark of lower case copy of string - the incoming arg is NOT changed
  654. */
  655. extern XrmQuark WcStringToQuark _((
  656.             char*    /* copied, flattened, then quarkified */
  657. ));
  658.  
  659. extern XrmQuark WcSubStringToQuark _((
  660.             char*,    /* ptr to starting character in an array */
  661.             char*    /* ptr to ending character in same array */
  662. ));
  663.  
  664. /*  -- get case-sensitive quark of sub-string (without flattening case)
  665. */
  666. extern XrmQuark WcCSSubStringToQuark _((
  667.             char*,    /* ptr to starting character in an array */
  668.             char*    /* ptr to ending character in same array */
  669. ));
  670.  
  671. /*  -- Various safe wrappers around string functions
  672. */
  673. extern char* WcStrStr  _(( char*, char* ));    /* find str1 in str2    */
  674. extern char* WcStrCpy  _(( char*, char* ));        /* safe strcpy    */
  675. extern char* WcStrCat  _(( char*, char* ));        /* safe strcat    */
  676. extern int   WcStrCmp  _(( char*, char* ));        /* safe strcmp    */
  677. extern int   WcStrCmpN _(( char*, char*, int ));    /* safe strncmp    */
  678.  
  679. #define WcNonNull(str) (int)((str) && *(str))
  680. #define WcNull(str)  (int)(!((str) && *(str)))
  681. #define WcStrLen(str) (int)(((str) && *(str))?strlen(str):0)
  682. #define WcStrEq(s1,s2) (int)(!WcStrCmp((s1),(s2)))
  683. #define WcStrEqN(s1,s2,n) (int)(!WcStrCmpN((s1),(s2),(n)))
  684.  
  685. /* -- This is used to determine the number of `%s' replacement characters in
  686.  *    a string which is intended to be passed to printf() as a format
  687.  *    specification.  It returns 0 if something other than strings are expected
  688.  *    by the format specification.  It also returns 0 if a string format
  689.  *    specification contains a '*' which means the width or precision is
  690.  *    parametric.  Therefore, a positive return value means printf() can be
  691.  *    safely called with the returned number of strings as arguments following
  692.  *    the format.
  693.  */
  694. extern int   WcPrintfFormatStrings _(( char* ));
  695.  
  696. /*============================================================================
  697.  * Set resource values on widgets
  698.  * These procedures make it easier to use strings as the base protocol for 
  699.  * communicating with widgets.  This means you can use the same strings to
  700.  * dynamically change widget resources as you do to initialize them in the
  701.  * resource files.  The widget provided converters are used to convert the
  702.  * strings into the types required by the widget.
  703.  */
  704.  
  705. /*  -- Set resource values on widgets.  The string is of the format:
  706.  *    <set_string>    ::=    <res_spec_list>
  707.  *            |    <res_spec>
  708.  *
  709.  *    <res_spec_list>    ::=    ( <res_spec> )
  710.  *            |    <res_spec_list> ( <res_spec> )
  711.  *
  712.  *    <res_spec>    ::=    <targetName>.<resName>: <resValue>
  713.  *            |    <targetName>.<resName>(<resType>): <resValue>
  714.  *
  715.  *    <targetName>    ::=    <empty>
  716.  *            |    this
  717.  *            |    <relative_opt><widget_path>
  718.  *
  719.  * If there are multiple resource specs, then each must be enclosed
  720.  * in parens.
  721.  *
  722.  * In other words, a resource spec looks just like a line in a resource file,
  723.  * except that it may include an optional resource type specification in
  724.  * parens, and the name of the targetWidget may be 'this' or a relative path
  725.  * as well as the standard wildcarded paths.  An empty targetName is the
  726.  * same as 'this'.
  727.  *
  728.  * The special resource value of "this" means "this widget."  Typically,
  729.  * using "this" as the resource value is used to set the "XmNdefaultButton"
  730.  * resource on a XmbulletinBoard, "menuBar", "workArea", etc on XmMainWindows,
  731.  * the subMenuId resource on menuBar cascade buttons, and so on.
  732.  *
  733.  * The targetName must resolve to a specific widget: therefore the last
  734.  * component of the targetName must be the name of a Widget instance, and
  735.  * the targetName MUST be followed by a '.' and NOT a '*'.
  736.  *
  737.  * Caution: only use resource_type when you REALLY must, as this is not safe.
  738.  * With sub-resources you will need it.
  739.  */
  740. extern void WcSetValue _((
  741.         Widget,        /* refernce widget, not necessarly altered! */
  742.         char*        /* <set_string> as defined above */
  743. ));
  744.  
  745. /* -- Set a single resource on a single widget
  746. */
  747. extern void WcSetValueFromString _((
  748.         Widget,        /* widget to change */
  749.         char*,        /* name of resource (like XtNforground) */
  750.         char*        /* value of resource (like "red") */
  751. ));
  752.  
  753. /* -- Set a single resource on a single widget.  Use only if the widget
  754.  *    does not include the resource in its class resources rec, nor in its
  755.  *    constraint resources.  With sub-resources you will need it.
  756.  *    You can try to get the type with WcGetResourceType(), and if you get
  757.  *    NULL, then the widget is mis-implemented (or its a sub-resource) and
  758.  *    you will need to somehow figure out the appropriate type, like XtRWidget.
  759.  */
  760. extern void WcSetValueFromStringAndType _((
  761.         Widget,        /* widget to change */
  762.         char*,        /* resource name (like "fontList") */
  763.         char*,        /* resource value (like "*times*--14-*") */
  764.         char*        /* resource type (like "FontList") */
  765. ));
  766.  
  767. /* -- Determine the type of the named resource.  Checks both normal widget
  768.  *    resources and constraint resources which may apply to an instance.
  769.  *    XtFree the return value.  Returns NULL if the widget pretends it does
  770.  *    not have this resource (which is generally a widget bug, and usually
  771.  *    implies the resource is a sub-resource).
  772.  */
  773. extern char* WcGetResourceType _((
  774.         Widget,        /* Check resource types for this instance */
  775.         char*        /* return type of this resource, or NULL */
  776. ));
  777.  
  778. /* -- Set translations on a widget based on a translation string which includes
  779.  *    #augment, #replace, or #override directives (default to #replace).
  780.  */
  781. extern void WcSetTranslations _((
  782.         Widget,        /* set translations on this widget */
  783.         char*        /* string describing translations */
  784. ));
  785.  
  786. /* -- Load a resource file (file is loaded once only per display), returns
  787.  *    TRUE if loaded.  Note that in general you must be careful when using
  788.  *    this function.  If you load resources which override existing values,
  789.  *    the overriden values are free'd.  If someone is trying to use resource
  790.  *    values in-place (which they should not, but...) then you may eventually
  791.  *    get a core dump.  Or maybe not.  Wcl uses this function, but only during
  792.  *    Wcl initialization.  At this time, there are few users of the database,
  793.  *    and those users (applicationShellWidgetClass, Wcl, Xt) do not use
  794.  *    in-place resource values, only copies.  Be careful!
  795.  */
  796. extern int WcLoadResourceFile _((
  797.         Widget,        /* for Display* and  XtAppContext */
  798.         char*        /* name of file to load */
  799. ));
  800.  
  801. /*============================================================================
  802.  * Callback And Action Support
  803.  * Applications can export their methods to the widgets in the form of
  804.  * XtCallbackProcs or XtActionProcs.  Wcl and the XtTranslationManager provide
  805.  * the argument(s) between parentheses as character strings to the methods.
  806.  * Callback procs receive the string between parenthesis as a single string,
  807.  * actions receive the same string broken up into words.  If the method needs
  808.  * to parse the arguments, one or the other form may be more convenient.
  809.  *
  810.  * For example, WcUnmanage() requires no real parsing if implemented as an
  811.  * XtActionProc as it only uses the arguments as individual words.  However,
  812.  * WcSetValue() must do more sophisticated parsing, and so it is easier to
  813.  * implement as a callback.  Wcl implements each of the 30 odd conveneince
  814.  * procedures as either callbacks or actions (choosing the form which is most
  815.  * convenient for implementation) and then it simply invokes the convenient
  816.  * form from the less convenient form: WcManageCB() invokes WcManageACT(),
  817.  * whereas WcSetValuesACT() invokes WcSetValuesCB().
  818.  */
  819.  
  820. /* -- Invoke an XtActionProc easily from an XtCallbackProc
  821. */
  822. extern void WcInvokeAction _((
  823.         XtActionProc,    /* invoke this action proc */
  824.         Widget,        /* the widget the callback proc received */
  825.         char*        /* the client data string Wcl gave the CB */
  826. ));
  827.  
  828. extern void WcInvokeNamedAction _((
  829.         char*,        /* Name of action proc to invoke (needs R4) */
  830.         Widget,        /* the widget the callback proc received */
  831.         char*        /* the client data string Wcl gave the CB */
  832. ));
  833.  
  834. /* -- Invoke an XtCallbackProc easily from an XtActionProc
  835. */
  836. extern void WcInvokeCallback _((
  837.         XtCallbackProc,    /* invoke this callback proc */
  838.         Widget,        /* the widget the action proc received */
  839.         char**,        /* the "params" recvd from XtTranslationMgr */
  840.         Cardinal*    /* "num_params" recvd from XtTranslationMgr */
  841. ));
  842.  
  843. /*============================================================================
  844.  * Convenience Callbacks and Actions provided by Wcl
  845.  *
  846.  * In all cases, unless explicitly stated, the names of widgets taken
  847.  * as arguments to the following callbacks and actions are resolved using
  848.  * WcFullNameToWidget(), and therefore the names can always be relative
  849.  * widget path names.  The "reference widget" is the widget which invoked
  850.  * the callback or action proc.
  851.  *
  852.  * Also, each of these callbacks and actions are registered with Wcl with
  853.  * the "CB" or "ACT" suffixes and without.  Therefore, in resource files you
  854.  * can name WcManageCB() with either WcManage or WcManageCB, and WcManageACT()
  855.  * with either WcManage or WcManageACT.
  856.  */
  857.  
  858. /* -- WcManage( widgetName [, widgetName] ... )
  859.  *    Manages each of the named widgets.  Uses XtManageChildren as much
  860.  *    as possible.
  861.  */
  862. extern void WcManageCB  _(( Widget, XtPointer, XtPointer ));
  863. extern void WcManageACT _(( Widget, XEvent*, char**, Cardinal* ));
  864.  
  865. /* -- WcUnmanage( widgetName [, widgetName] ... )
  866.  *    Unmanages each of the named widgets.
  867.  */
  868. extern void WcUnmanageCB  _(( Widget, XtPointer, XtPointer ));
  869. extern void WcUnmanageACT _(( Widget, XEvent*, char**, Cardinal* ));
  870.  
  871. /* -- WcManageChildren( parentWidgetName, child [, child] ... )
  872.  *    The parentWidgetName is resolved using WcFullNameToWidget().  However,
  873.  *    Each of the children must be single component names of direct descendents
  874.  *    of the parent widget.  No wildcards or relative names are allowed for the
  875.  *    children names.
  876.  */
  877. extern void WcManageChildrenCB  _(( Widget, XtPointer, XtPointer ));
  878. extern void WcManageChildrenACT _(( Widget, XEvent*, char**, Cardinal* ));
  879.  
  880. /* -- WcUnmanageChildren( parentWidgetName, child [, child] ... )
  881.  *    See WcManageChildren for comments about the arguments.
  882.  */
  883. extern void WcUnmanageChildrenCB  _(( Widget, XtPointer, XtPointer ));
  884. extern void WcUnmanageChildrenACT _(( Widget, XEvent*, char**, Cardinal* ));
  885.  
  886. /* -- WcDestroy( widgetName [, widgetName] ... )
  887.  *    Calls XtDestroyWidget with each of the named widgets.  The 2-phase
  888.  *    destroy mechanism makes this safe.
  889.  */
  890. extern void WcDestroyCB  _(( Widget, XtPointer, XtPointer ));
  891. extern void WcDestroyACT _(( Widget, XEvent*, char**, Cardinal* ));
  892.  
  893. /* -- WcSetSensitive( widgetName [, widgetName] ... )
  894.  *    Makes each named widget sensitive by calling XtSetSensitive.  Note that
  895.  *    gadgets cannot be made insensitive: a warning message is generated.
  896.  */
  897. extern void WcSetSensitiveCB  _(( Widget, XtPointer, XtPointer ));
  898. extern void WcSetSensitiveACT _(( Widget, XEvent*, char**, Cardinal* ));
  899.  
  900. /* -- WcSetInsensitive( widgetName [, widgetName] ... )
  901.  *    See WcSetSensitive for comments about the arguments.
  902.  */
  903. extern void WcSetInsensitiveCB  _(( Widget, XtPointer, XtPointer ));
  904. extern void WcSetInsensitiveACT _(( Widget, XEvent*, char**, Cardinal* ));
  905.  
  906. /* -- WcPopup( shellWidgetName [, shellWidgetName] ... )
  907.  *    Named widgets must be shells.  This invokes XtPopup(), passing XtGrabNone
  908.  */
  909. extern void WcPopupCB  _(( Widget, XtPointer, XtPointer ));
  910. extern void WcPopupACT _(( Widget, XEvent*, char**, Cardinal* ));
  911.  
  912. /* -- WcPopupGrab( shellWidgetName [, shellWidgetName] ... )
  913.  *    Requires shell widgets.  This invokes XtPopup(), passing XtGrabExclusive
  914.  */
  915. extern void WcPopupGrabCB  _(( Widget, XtPointer, XtPointer ));
  916. extern void WcPopupGrabACT _(( Widget, XEvent*, char**, Cardinal* ));
  917.  
  918. /* -- WcPopdown( shellWidgetName [, shellWidgetName] ... )
  919.  *    The named widgets must be shell widgets.  Each shell is popped-down
  920.  *    via a call to XtPopdown.  This releases any grabs by the shells.
  921.  */
  922. extern void WcPopdownCB  _(( Widget, XtPointer, XtPointer ));
  923. extern void WcPopdownACT _(( Widget, XEvent*, char**, Cardinal* ));
  924.  
  925. /* -- WcMap( widgetName [, widgetName] ... )
  926.  *    Causes each of the named widgets to be mapped via XtMapWidget()
  927.  */
  928. extern void WcMapCB  _(( Widget, XtPointer, XtPointer ));
  929. extern void WcMapACT _(( Widget, XEvent*, char**, Cardinal* ));
  930.  
  931. /* -- WcUnmap( widgetName [, widgetName] ... )
  932.  *    Causes each of the named widgets to be un-mapped via XtUnmapWidget()
  933.  */
  934. extern void WcUnmapCB  _(( Widget, XtPointer, XtPointer ));
  935. extern void WcUnmapACT _(( Widget, XEvent*, char**, Cardinal* ));
  936.  
  937. /* -- WcInstallAccelerators( dest, src [, src] ... )
  938.  *    dest  - (root of tree) widget that can activate accelerators,
  939.  *    src   - widget which provides functionality,
  940.  *        and defines the accel translation (accelerators resource).
  941.  */
  942. extern void WcInstallAcceleratorsCB  _(( Widget, XtPointer, XtPointer ));
  943. extern void WcInstallAcceleratorsACT _(( Widget, XEvent*, char**, Cardinal* ));
  944.  
  945. /* -- WcInstallAllAccelerators( dest, src )
  946.  *    dest  - (root of tree) widget that can activate accelerators,
  947.  *    src   - root of widget tree, each widget can provide functionality,
  948.  *        and can define an accel translation (accelerators resource).
  949.  */
  950. extern void WcInstallAllAcceleratorsCB  _((Widget, XtPointer, XtPointer ));
  951. extern void WcInstallAllAcceleratorsACT _((Widget, XEvent*, char**, Cardinal*));
  952.  
  953. /* -- WcCreateRoot( shell [on: display] [shell [on: display]] ... )
  954.  *    Creates a new application shell.  Although the display name is optional,
  955.  *    it is effectively mandatory because Xt does not fully define behavior
  956.  *    when there are multiple applicationShells on the same display connection.
  957.  *    The name of the shell must be a single component name: it will have no
  958.  *    parent.
  959.  */
  960. extern void WcCreateRootCB  _(( Widget, XtPointer, XtPointer ));
  961. extern void WcCreateRootACT _(( Widget, XEvent*, char**, Cardinal* ));
  962.  
  963. /* -- WcSpawn( <cmd_arguments> )
  964.  *    Forks and execvp a new process.  The <cmd_arguments> are passed to the
  965.  *    main() of the new process as argc and argv.  The command line is NOT
  966.  *    a shell command line.  See WcSystem().
  967.  */
  968. extern void WcSpawnCB  _(( Widget, XtPointer, XtPointer ));
  969. extern void WcSpawnACT _(( Widget, XEvent*, char**, Cardinal* ));
  970.  
  971. /* -- WcLoadResourceFile( file [, file] )
  972.  *    Be careful when you use this!!   See the comments for the function
  973.  *    of the same name.
  974.  */
  975. extern void WcLoadResourceFileCB  _(( Widget, XtPointer, XtPointer ));
  976. extern void WcLoadResourceFileACT _(( Widget, XEvent*, char**, Cardinal* ));
  977.  
  978. /* -- WcPrintTree( widgetName [, widgetName] )
  979.  *    Prints out widget tree starting with named widget(s).
  980.  */
  981. extern void WcPrintTreeCB  _(( Widget, XtPointer, XtPointer ));       
  982. extern void WcPrintTreeACT _(( Widget, XEvent*, char**, Cardinal* ));
  983.  
  984. /* -- WcDumpResources( widgetName [, widgetName] )
  985.  *    Print out resources under a widget instance.
  986.  */
  987. extern void WcDumpResourcesCB  _(( Widget, XtPointer, XtPointer ));
  988. extern void WcDumpResourcesACT _(( Widget, XEvent*, char**, Cardinal* ));
  989.  
  990. /* -- WcExit( [exitVal] )
  991.  *    Exit the application, returning the integer equivalent of exitVal.
  992.  */
  993. extern void WcExitCB  _(( Widget, XtPointer, XtPointer ));
  994. extern void WcExitACT _(( Widget, XEvent*, char**, Cardinal* ));
  995.  
  996. /* -- WcCreateChildren( parentWidgetName, child [,child] ... )
  997.  *    The parent name can be a relative name, but each of the children are
  998.  *    named with a single component name.  This procedure is equivalent to
  999.  *    providing a wcChildren resource on the parent widget, except that
  1000.  *    the parent's creation-time resources are not evaluated: i.e., the
  1001.  *    creation-time callbacks of the parent are NOT invoked.
  1002.  */
  1003. extern void WcCreateChildrenCB  _(( Widget, XtPointer, XtPointer ));
  1004. extern void WcCreateChildrenACT _(( Widget, XEvent*, char**, Cardinal* ));
  1005.  
  1006. /* -- WcCreatePopups( parentWidgetName, child [,child] ... )
  1007.  *    The parent name can be a relative name, but each of the children are
  1008.  *    named with a single component name.  This procedure is equivalent to
  1009.  *    providing a wcPopup resource on the parent widget, except that
  1010.  *    the parent's creation-time resources are not evaluated: i.e., the
  1011.  *    creation-time callbacks of the parent are NOT invoked.
  1012.  */
  1013. extern void WcCreatePopupsCB  _(( Widget, XtPointer, XtPointer ));
  1014. extern void WcCreatePopupsACT _(( Widget, XEvent*, char**, Cardinal* ));
  1015.  
  1016. /* -- WcPositionTransient()
  1017.  *    Position a TransientShell in middle of parent widget.  This callback
  1018.  *    is useful as a popupCallback or as an action triggered by the <MapNotify>
  1019.  *    event.
  1020.  */
  1021. extern void WcPositionTransientCB  _(( Widget, XtPointer, XtPointer ));
  1022. extern void WcPositionTransientACT _(( Widget, XEvent*, char**, Cardinal* ));
  1023.  
  1024. /* -- WcSetValue( <set_string> )
  1025.  *    This callback and action are simple wrappers around WcSetValue().
  1026.  *    See the comments above for the sytax of the <set_string> argument.
  1027.  */
  1028. extern void WcSetValueCB  _(( Widget, XtPointer, XtPointer ));
  1029. extern void WcSetValueACT _(( Widget, XEvent*, char**, Cardinal* ));
  1030.  
  1031. /* -- WcTrace( annotation )
  1032.  *    Prints to stderr the wiget pathname of the invoking wiget, and an
  1033.  *    optional annotation.
  1034.  */
  1035. extern void WcTraceCB  _(( Widget, XtPointer, XtPointer ));
  1036. extern void WcTraceACT _(( Widget, XEvent*, char**, Cardinal* ));
  1037.  
  1038. /* -- WcSystem( shellCmdString )
  1039.  *    Invokes system(), passing the shellCmdString.  Note this does NOT
  1040.  *    fork, so it will block unless you append a `&' at the end of the
  1041.  *    shellCmdString.
  1042.  */
  1043. extern void WcSystemCB  _(( Widget, XtPointer, XtPointer ));
  1044. extern void WcSystemACT _(( Widget, XEvent*, char**, Cardinal* ));
  1045.  
  1046. /* -- WcAddCallbacks( widgetName callbackName CbProc(args) [CbProc(args) ...] )
  1047.  *    This is the socially acceptable way to add callback procedures to
  1048.  *    callback resources of widgets.  You generally should not use WcSetValue().
  1049.  *    You must specify the callback list name (like popupCallback) as well
  1050.  *    as one or more callback procedure names.  The args for each callback
  1051.  *    procedure are optional.  The syntax for the callback names are discussed
  1052.  *    under "Method Support" and "Dynamic Library Support" above.
  1053.  */
  1054. extern void WcAddCallbacksCB  _(( Widget, XtPointer, XtPointer ));
  1055. extern void WcAddCallbacksACT _(( Widget, XEvent*, char**, Cardinal* ));
  1056.  
  1057. /* -- WcRemoveCallbacks( widName callbackName CbProc(args) [CbProc(args) ...] )
  1058.  *    This is the socially acceptable way to remove callback procedures from
  1059.  *    callback resources of widgets.  
  1060.  *    You must specify the callback list name (like popupCallback) as well
  1061.  *    as one or more callback procedure names.  The args for each callback
  1062.  *    procedure must be the same (except for leading and trailing whitespace).
  1063.  *    I.e., you must use the same internal whitespace, commas, and
  1064.  *    capitailization as when you set the callback resource value.
  1065.  */
  1066. extern void WcRemoveCallbacksCB  _(( Widget, XtPointer, XtPointer ));
  1067. extern void WcRemoveCallbacksACT _(( Widget, XEvent*, char**, Cardinal* ));
  1068.  
  1069. /* -- WcOnceOnly( callbackName CbProc( args ) [CbProc( args ) ...] )
  1070.  *    Note that we must have the callback list name!
  1071.  *    This allows the list of callbacks to each be invoked exactly once, the
  1072.  *    first time the callbacks on the callback list is traversed by the widget.
  1073.  *    The callbacks are invoked in left to right order.  Note that this is
  1074.  *    NOT true for callbacks in other contexts!  Xt does not guarantee any
  1075.  *    callback procedure invocation order.  However, since WcOnceOnlyCB is
  1076.  *    the callback invoked from the callback list from Xt, and each CbProc()
  1077.  *    is then invoked by WcOnceOnly(), the order can be guaranteed.
  1078.  */
  1079. extern void WcOnceOnlyCB  _(( Widget, XtPointer, XtPointer ));
  1080. extern void WcOnceOnlyACT _(( Widget, XEvent*, char**, Cardinal* ));
  1081.  
  1082. /* -- WcTranslations( widgetName translationString )
  1083.  *    Augment or override translations on the named widget.
  1084.  */
  1085. extern void WcTranslationsCB  _(( Widget, XtPointer, XtPointer ));
  1086. extern void WcTranslationsACT _(( Widget, XEvent*, char**, Cardinal* ));
  1087.  
  1088. /* -- WcDynamicCallback(  sharedLibrary nameOfXtCallbackProc([optArgs]) )
  1089.  *    This is really made obsolete by the new (Wcl 2.02) callback naming syntax.
  1090.  *    The sharedLibrary argument must be a full pathname, a path starting from
  1091.  *    ~, or a library abbreviation for libraries registered with the
  1092.  *    WclDynamicLibs resource or the WcRegisterDynamicLibs() function.  See the
  1093.  *    discussion under "Dynamic Library Support" above.
  1094.  */
  1095. extern void WcDynamicCallbackCB  _(( Widget, XtPointer, XtPointer ));
  1096. extern void WcDynamicCallbackACT _(( Widget, XEvent*, char**, Cardinal* ));
  1097.  
  1098. /* -- WcDynamicAction( sharedLibrary nameOfXtActionProc([optArgs]) )
  1099.  *    This is not yet obsolete.  Doing late binding of actions is not so
  1100.  *    simple...
  1101.  *    ~, or a library abbreviation for libraries registered with the
  1102.  *    WclDynamicLibs resource or the WcRegisterDynamicLibs() function.  See the
  1103.  *    discussion under "Dynamic Library Support" above.
  1104.  */
  1105. extern void WcDynamicActionCB  _(( Widget, XtPointer, XtPointer ));
  1106. extern void WcDynamicActionACT _(( Widget, XEvent*, char**, Cardinal* ));
  1107.  
  1108.  
  1109. /* -- For backward compatibility, these functions do nothing at all
  1110. */
  1111. extern void WcAllowDuplicateRegistration     _(( int ));
  1112. extern void WcAllowDuplicateClassPtrReg      _(( int ));
  1113. extern void WcAllowDuplicateClassNameReg     _(( int ));
  1114. extern void WcAllowDuplicateConstructorReg     _(( int ));
  1115. extern void WcAllowDuplicateCallbackReg         _(( int ));
  1116.  
  1117. #endif /* _WcCreate_h */
  1118.